import java.util.*;
/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: AliceMana
 * Date: 2022-10-05
 * Time: 12:37
 */

// https://leetcode.cn/problems/range-sum-query-2d-immutable/
class NumMatrix {
    public int[][] arr = new int[220][220];
    public NumMatrix(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                arr[i][j] = arr[i][j-1] + arr[i-1][j] - arr[i-1][j-1] + matrix[i-1][j-1];
            }
        }
    }

    public int sumRegion(int x1, int y1, int x2, int y2) {
        x1++; y1++;
        x2++; y2++;
        return arr[x2][y2] - arr[x2][y1-1] - arr[x1-1][y2] + arr[x1-1][y1-1];
    }
}
// https://leetcode.cn/problems/range-sum-query-immutable/
class NumArray {
    public long[] arr;
    public NumArray(long[] nums) {
        arr = new long[nums.length+10];
        // 前缀和从1开始
        for (int i = 1; i <= nums.length; i++) {
            arr[i] = arr[i-1] + nums[i-1];
        }
    }

    public long sumRange(int left, int right) {
        left++;
        right++;
        return arr[right] - arr[left-1];
    }
}
class Report implements Comparable<Report>{

    public String name;
    public String score;
    public String score2;

    @Override
    public int compareTo(Report o) {
        if (this.score.compareTo(o.score) != 0) {
            return o.score.compareTo(this.score);
        }
        // 两个成绩一样，按字典排序
        return this.name.compareTo(o.name);
    }

    @Override
    public String toString() {
        return this.name + " " + this.score2;
    }
}
public class Main {
    public static String removeZero(String source) {
        int n = source.length();
        int index = 0;
        for (int i = n - 1; i >= 0; i--) {
            if (source.charAt(i) != '0') {
                index = i;
                break;
            }
        }
        return source.substring(0, index + 1);
    }

    //第一次期中考终于结束啦！沃老师是个语文老师，他在评学生的作文成绩时，给每位学生的分数都是一个小于10的非负小数。
    //沃老师并不会告诉大家分数的排名，但学生间竞争激烈，大家都想知道自己的作文成绩在班上的排名。
    //但由于作文分数的小数部分可能超级长，难以用肉眼比较两个数的大小关系，请你帮忙写个程序，把所有学生按照作文分数排序吧〜
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        in.nextLine();
        List<Report> reports = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            Report report = new Report();
            report.name = in.next();
            report.score2 = in.next();
            report.score = removeZero(report.score2);
            reports.add(report);
        }
        Collections.sort(reports);
        for (Report l :
                reports) {
            System.out.println(l);
        }
    }





    public static double getSimilarity (String correct, String toCompared) {
        double k = 0.0;
        if (correct.length() != toCompared.length()) {
            return 0;
        }
        int numberOfIdenticalLetters = 0;
        for (int i = 0; i < correct.length(); i++) {
            if (correct.charAt(i) == toCompared.charAt(i)) {
                numberOfIdenticalLetters++;
            }
        }
        k = numberOfIdenticalLetters/(double)toCompared.length();
        return k;
    }

    public static void main7(String[] args) {
        Scanner in = new Scanner(System.in);
        String rightKey = in.nextLine();
        int n = in.nextInt();
        String[] studentKey = new String[n];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            studentKey[i] = in.nextLine();
        }
        Arrays.sort(studentKey);
        List<String> identicalKValue = new ArrayList<>();
        List<Double> kValue = new ArrayList<>();
        double max = 0.0;
        for (String s : studentKey) {
            double k = getSimilarity(s, rightKey);
            identicalKValue.add(s);
            kValue.add(k);
            if (k > max) {
                max = k;
            }
        }
        int[] index = new int[kValue.size()];
        int subscript = 0;
        while (kValue.contains(max)) {
            index[subscript++] = kValue.indexOf(max);
            kValue.remove(max);
        }
        int flg = 1;
        for (int i = 0; i < index.length; i++) {
            if (index[i] != 0) {
                flg = 0;
            }
        }
        if (flg == 1) {
            for (String s:identicalKValue) {
                System.out.println(s);
            }
        }
        for (int i = 0; index[i] != 0; i++) {
            System.out.println(identicalKValue.get(index[i]));
            identicalKValue.remove(i);
        }
    }

    //中国文化的五行：金、木、水、火、土相生相克， 一天Alice和Bob玩起了卡牌游戏。卡牌包含5种类型Jin，Mu，Shui，Huo，Tu，
    // 分别代表金、木、水、火、土。
    //
    //金克木，木克土，土克水，水克火，火克金。游戏规则如下：
    //
    //两人玩n轮，每轮各自抽取一张卡牌，如果其中一个人的牌克制另一个人的牌那么这个人得3分，另一个人得0分。
    // 没有克制关系两人都得1分。最后得分高的获胜。
    public static void main6(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String[] strings = new String[n];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            strings[i] = in.nextLine();
        }
        int aliceScore = 0;
        int bobScore = 0;
        for (int i = 0; i < n; i++) {
            String[] tmp = strings[i].split(" ");
            switch (tmp[0]) {
                case "Jin":
                    if (tmp[1].equals("Mu")) {
                        aliceScore += 3;
                    } else if (tmp[1].equals("Huo")) {
                        bobScore += 3;
                    } else {
                        aliceScore++;
                        bobScore++;
                    }
                    break;
                case "Mu":
                    if (tmp[1].equals("Tu")) {
                        aliceScore += 3;
                    } else if (tmp[1].equals("Jin")) {
                        bobScore += 3;
                    } else {
                        aliceScore++;
                        bobScore++;
                    }
                    break;
                case "Shui":
                    if (tmp[1].equals("Huo")) {
                        aliceScore += 3;
                    } else if (tmp[1].equals("Tu")) {
                        bobScore += 3;
                    } else {
                        aliceScore++;
                        bobScore++;
                    }
                    break;
                case "Huo":
                    if (tmp[1].equals("Jin")) {
                        aliceScore += 3;
                    } else if (tmp[1].equals("Shui")) {
                        bobScore += 3;
                    } else {
                        aliceScore++;
                        bobScore++;
                    }
                    break;
                case "Tu":
                    if (tmp[1].equals("Shui")) {
                        aliceScore += 3;
                    } else if (tmp[1].equals("Mu")) {
                        bobScore += 3;
                    } else {
                        aliceScore++;
                        bobScore++;
                    }
                    break;
            }
        }
        if (aliceScore > bobScore) {
            System.out.println("Alice");
        } else if (aliceScore < bobScore) {
            System.out.println("Bob");
        } else {
            System.out.println("Draw");
        }
    }


    //小w想和你van纸牌
    //小w有两张纸牌，两张纸牌上都有相同的正整数n
    //每一轮一张纸牌上的数都可以减去小于等于另外一张纸牌上的数的数
    //每一轮只能操作和上轮不同的纸牌
    //小w想知道三轮之后两纸牌上数字之和的最小值
    //注意，不能减为负数
    public static void main5(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = a;
        a -= b/2;
        b -= a;
        a -= b;
        System.out.println(a+b);
    }
    //给一个数组 a，长度为 n，若某个子序列中的和为 K 的倍数，那么这个序列被称为“K 序列”。现在要你
    // 对数组 a 求出最长的子序列的长度，满足这个序列是 K 序列。
    public static void main4(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }
        NumArray numArray = new NumArray(arr);

        for (int i = n-1; i >= 0; i--) {
            for (int j = 0; j <= n-i; j++) {
                if ((numArray.sumRange(j, i))%k == 0) {
                    System.out.println(i - j + 1);
                    return;
                }
            }
        }
    }


    //“这个比赛，归根结底就是控制一个虚拟的小拖拉机跑完整个赛道。一般一场比赛会有 9 个到 13 个赛道，最后看能跑完多少个赛道。”
    //通常在一场可编程拖拉机比赛中，分别会有实际参赛队伍数 10%、20%、30% 向下取整的队伍获得金、银、铜牌，其余队伍获得荣誉提名，俗称“铁牌”。
    //但是主办方往往会多准备一些奖牌，那么在发奖牌的时候会按照比例向上取整发出的奖牌以减少浪费，就会有一些原本获得银牌的队伍获得了金牌。
    //现在给出一个赛区的规模，也就是这个赛区的实际参赛队伍数，小 Q 同学想知道有多少队伍的奖牌会由银变金、由铜变银、由铁变铜。
   public static boolean numberOfMedalsIncreased (int n, int range) {
       return n % (10/range) != 0;
   }


    public static void main3(String[] args) {
        Scanner in = new Scanner(System.in);
        int gold = 0;
        int silver = 0;
        int copper = 0;
        int n = in.nextInt();
        if (numberOfMedalsIncreased(n, 1)) {
            gold++;
            silver++;
            copper++;
        }
        if (numberOfMedalsIncreased(n, 2)) {
            silver++;
            copper++;
        }
        if (numberOfMedalsIncreased(n, 3)) {
            copper++;
        }
        System.out.print(gold+" "+silver+" "+copper);
    }
    /*public static boolean roundUp (float n) {
        return n - (int) n != 0;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int res1 = n;
        int res2 = n;
        int a1, b1, c1;
        float a2, b2, c2;
        a1 = res1*10/100;
        res1 -= a1;
        b1 = res1*20/100;
        res1 -= b1;
        c1 = res1*30/100;

        a2 = res2*0.1f;
        int tmp;
        int ret1;
        int ret2;
        if (roundUp(a2)) {
            tmp = (int) a2+1;
            ret1 = (int)a2 - a1 + 1;
            System.out.print((int)a2 - a1 + 1);
        } else {
            tmp = (int) a2;
            ret1 = (int)a2 - a1;
            System.out.println(ret1);
        }
        System.out.print(" ");
        res2 -= tmp;
        b2 = res2*0.2f;
        if (roundUp(b2)) {
            tmp = (int) b2+1;
            ret2 = (int)b2 - b1 + 1;
            System.out.print(ret1);
        } else {
            tmp = (int) b2;
            ret2 = (int)b2 - b1;
            System.out.println(ret1);
        }
        System.out.print(" ");
        res2 -= tmp;
        c2 = res2*0.3f;
        if (roundUp(c2)) {
            tmp = (int) c2+1;
            System.out.print((int)c2 - c1 + 1 + ret1+ret2);
        } else {
            tmp = (int) c2;
            System.out.println((int)c2 - c1+ret1+ret2);
        }
        System.out.println();
    }*/
    //小P和小Q是好朋友，今天他们一起玩一个有趣的游戏。
    //他们的初始积分都为1，赢的人可以将自己的分数乘以 (K的平方)，而输的人也能乘以K。
    //他们玩的太开心了，以至于忘了自己玩了多久，甚至 K 是多少和游戏进行的回合数 N 都忘了。
    //现在给出他们俩最终的积分a,b，请问是否存在正整数K、N满足这样的积分，判断他们的游戏结果是否可信。
    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        while (in.hasNextInt()) {
            long f = in.nextLong();
            long s = in.nextLong();
            long product = f*s;
            float res = (float) Math.pow(product, 1.0/3);
            if (res == (int) res) {
                System.out.println("Yes");
            } else {
                System.out.println("No");
            }
        }
    }


    //现在给出一个正方形地图，其边长为n，地图上有的地方是空的，有的地方会有敌人。
    //我们现在有一次轰炸敌人的机会，轰炸敌人的区域是一个k*k的正方形区域，现在需要你解决的问题就是计算最多轰炸的敌人数量是多少。
    public static void main1(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int n = in.nextInt();
            int k = in.nextInt();
            int[][] arr = new int[100][100];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    arr[i][j] = in.nextInt();
                }
            }
            NumMatrix numMatrix = new NumMatrix(arr);
            int max = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    max = Math.max(max, numMatrix.sumRegion(i, j, i+k-1, j+k-1));
                }
            }
            System.out.println(max);
        }
    }
}
